how does this affect errors when using serialize_with?

I've checked the difference in error messages locally with serde(with) and it doesn't change (e.g. when the signature of the given function is wrong). I can add a ui snapshot test for that today in the evening.

Also, the error for serde(with) still points to the macro call site (not to the function in the serde(with) attribute) as it was before my changes and after. That can also be improved by wrapping the function itself in a ::core::convert::identity<fn(#(#field_types,)*) -> __S> which gives the type hint for the function signature and the compiler starts complaing that the function is wrong, so it points the error to the function directly. However, this unfortunatelly coerces the function to a function pointer...

As a workaround that hint could be inside of an if false:

if false {
    let _: fn( #(field_types,)*) -> __S = #fn_path;
}

// ... actual usage of `#fn_path` is unchanged

But this will just produce more errors (on inside of the if and one at the site where #fn_path is actually used.

One more alternative would be to generate an identity function like this:

fn type_hint<F: Fn(...) -> __S>(f: F) -> F { f }

that would give a type hint without an fn pointer coersion. But it would need to be a method on the internal SerdeWith wrapper struct, because it needs to inherit the generics and field types from it.

Also.. it will just increase the compile times because rustc will need to typecheck that type_hint function additionally.

with attributes fixed by me in #2558

Interesting... So I suppose it's enough to wrap the expression of the function invocation with quote_spanned for this to work?

I wonder what if I attach the span of the type itself to the parameter of serialize_field/entry... Maybe it'll yield the same result. I'll experiment with this later today.

Otherwise I suppose #2558 should land first, because it looks like it may conflict with this PR?

Not sure. I'm ready to rebase all my PRs once their fall into conflict state

I've checked how it works. The similar behavior can be achieved if even with the expression serialize_field::<_> where the span of _ is assigned to the span of the field type.

This is because with the explicit turbofish compiler emits an error pointing to it:

error[E0277]: the trait bound `NoImpls: _::_serde::Serialize` is not satisfied
    --> crates/sandbox/src/main.rs:34:61
     |
34   |             _serde::ser::SerializeStruct::serialize_field::<_>(&mut __serde_state, "x2", &self.x2)?;
     |                                                             ^ the trait `_::_serde::Serialize` is not implemented for `NoImpls`
     |

So if its span points to smth else (like the field type), the compiler will point to the field type instead.

When there is no turbofish syntax, it's important that all parts of the field expression have the span of the field, because only then will the compiler point to the original field.

error[E0277]: the trait bound `NoImpls: _::_serde::Serialize` is not satisfied
    --> crates/sandbox/src/main.rs:34:85
     |
34   |             _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "x2", &self.x2)?;
     |             ---------------------------------------------                           ^^^^^^^^ the trait `_::_serde::Serialize` is not implemented for `NoImpls`
     |             |
     |             required by a bound introduced by this call

For example, if all tokens &, self, . and x2 have the span of the field, you'll get an error pointing to the field in this case:

error[E0277]: the trait bound `NoImpls: _::_serde::Serialize` is not satisfied
    --> crates/sandbox/src/main.rs:8:5
     |
8    |     x2: NoImpls,
     |     ^^ the trait `_::_serde::Serialize` is not implemented for `NoImpls`

Alothough.. it would be better if the error pointed to the type itself. What makes this harder to achieve is that quote_spanned doesn't change the span of the interpolated tokens. So for example, today the self token in the field expression uses the callsite span when it's interpolated:

But instead each usage of this token should change the span to the relevant field.